O que “use strict” faz em JavaScript e qual é o raciocínio por trás disso?

Este artigo sobre Javascript Strict Mode pode interessar a você: John Resig - ECMAScript 5 Strict Mode, JSON e mais
Para citar algumas partes interessantes:
O Modo estrito é um novo recurso do ECMAScript 5 que permite colocar um programa ou uma função em um contexto operacional "estrito". Esse contexto estrito impede que certas ações sejam realizadas e lança mais exceções.
E:
O modo estrito ajuda de duas maneiras:
Ele captura alguns erros comuns de codificação, lançando exceções.
Ela impede, ou gera erros, quando relativamente ações "inseguros" são tomadas (como o acesso ao objeto global).
Ele desativa recursos que são confusos ou mal planejados.
Além disso, note que você pode aplicar "modo estrito" para todo o arquivo ... Ou você pode usá-lo apenas para uma função específica (ainda citando o artigo de John Resig):
// Código não estrito ...
(função(){
"use estrito";
// Defina sua biblioteca estritamente ...
}) ();
// Código não estrito ...
O que pode ser útil se você tiver que misturar códigos novos e antigos ;-)
Então, suponho que seja um pouco como o "use strict" que você pode usar em Perl (daí o nome?): Ajuda a cometer menos erros, detectando mais coisas que podem levar a quebras.
O modo estrito agora é compatível com todos os principais navegadores.
Dentro dos módulos ECMAScript nativos (com instruções de importação e exportação) e classes ES6, o modo estrito está sempre ativado e não pode ser desativado.
|
É um novo recurso do ECMAScript 5. John Resig escreveu um bom resumo dele.
É apenas uma string que você coloca em seus arquivos JavaScript (no topo de seu arquivo ou dentro de uma função) que se parece com isto:
"use estrito";
Colocá-lo em seu código agora não deve causar problemas com os navegadores atuais, pois é apenas uma string. Isso pode causar problemas com o seu código no futuro, se ele violar o pragma. Por exemplo, se você atualmente tem foo = "bar" sem definir foo primeiro, seu código começará a falhar ... o que é uma coisa boa em minha opinião.
|
A declaração "use strict"; instrui o navegador a usar o modo estrito, que é um conjunto de recursos reduzido e mais seguro do JavaScript.
Lista de recursos (não exaustiva)
Não permite variáveis ​​globais. (Captura declarações de var ausentes e erros de digitação em nomes de variáveis)
Atribuições com falha silenciosa geram erro no modo estrito (atribuindo NaN = 5;)
As tentativas de excluir propriedades não elimináveis ​​irão lançar (excluir Object.prototype)
Exige que todos os nomes de propriedades em um literal objeto para ser único (var x = {x1: "1", x1: "2"})
Os nomes dos parâmetros da função devem ser exclusivos (soma da função (x, x) {...})
Proíbe a sintaxe octal (var x = 023; alguns desenvolvedores assumem erroneamente que um zero precedente não faz nada para alterar o número).
Proíbe com a palavra-chave
eval em modo estrito não introduz novas variáveis
Proíbe a exclusão de nomes simples (excluir x;)
Proíbe ligação ou cessão dos nomes eval e argumentos de qualquer forma
O modo estrito não alias propriedades do objeto de argumentos com os parâmetros formais. (ou seja, na função sum (a, b) {argumentos de retorno [0] + b;} Isso funciona porque os argumentos [0] estão vinculados a a e assim por diante.)
argumentos.callee não é compatível
[Ref: modo estrito, Mozilla Developer Network]
|
Se as pessoas estão preocupadas sobre o uso estrito uso pode valer a pena verificar este artigo:
Suporte ao 'modo estrito' ECMAScript 5 em navegadores. O que isso significa? NovoGeek.com - weblog de Krishna
Ele fala sobre o suporte do navegador, mas o mais importante é como lidar com isso com segurança:
function isStrictMode () {
retornar! isso;
}
/ *
retorna falso, pois 'este' se refere ao objeto global e
'! isto' torna-se falso
* /
function isStrictMode () {
"use estrito";
retornar! isso;
}
/ *
retorna verdadeiro, pois no modo estrito a palavra-chave 'this'
não se refere ao objeto global, ao contrário do JS tradicional.
Então, aqui, 'isso' é 'indefinido' e '! Isso' se torna verdade.
* /
|
Uma palavra de cautela, todos vocês programadores exigentes: aplicar "use strict" ao código existente pode ser perigoso! Essa coisa não é um adesivo alegre e alegre que você pode colocar no código para torná-lo "melhor". Com o pragma "use strict", o navegador repentinamente JOGARÁ exceções em lugares aleatórios que nunca lançara antes, só porque naquele ponto você está fazendo algo que o JavaScript padrão / livre permite alegremente, mas o JavaScript estrito abomina! Você pode ter violações de rigidez escondidas em chamadas raramente usadas em seu código que só lançarão uma exceção quando forem executadas - digamos, no ambiente de produção que seus clientes pagantes usam!
Se você for mergulhar, é uma boa ideia aplicar "use strict" junto com testes de unidade abrangentes e uma tarefa de compilação JSHint estritamente configurada que lhe dará alguma confiança de que não há canto escuro do seu módulo que explodirá terrivelmente só porque você tenha ativado o modo estrito. Ou, ei, aqui está outra opção: apenas não adicione "use strict" a nenhum de seu código legado, provavelmente é mais seguro assim, honestamente. DEFINITIVAMENTE, NÃO adicione "use strict" a nenhum módulo que você não possui oumanter, como módulos de terceiros.
Eu acho que mesmo sendo um animal enjaulado mortal, "usar estrito" pode ser uma boa coisa, mas você tem que fazer isso direito. O melhor momento para ser rigoroso é quando o seu projeto é novo e você está começando do zero. Configure JSHint / JSLint com todas as advertências e opções ativadas o máximo que sua equipe puder aguentar, obtenha um bom sistema de construção / teste / assert du jour equipado como Grunt + Karma + Chai e somente ENTÃO comece a marcar todos os seus novos módulos como " use estrito ". Esteja preparado para corrigir muitos erros e avisos mesquinhos. Certifique-se de que todos entendam a gravidade configurando a construção para FALHA se JSHint / JSLint produzir qualquer violação.
Meu projeto não era um projeto greenfield quando adotei "use strict". Como resultado, meu IDE está cheio de marcas vermelhas porque não tenho "use strict" em metade dos meus módulos, e JSHint reclama disso. É um lembrete sobre o que a refatoração devo fazer no futuro. Meu objetivo é ser livre de marcas vermelhas devido a todas as minhas declarações "use estrito" ausentes, mas isso está a anos de distância agora.
|
Usando 'use strict'; não torna seu código melhor de repente.
O modo estrito do JavaScript é um recurso do ECMAScript 5. Você pode habilitar o modo estrito declarando isso no início do seu script / função.
'use estrito';
Quando um mecanismo JavaScript vê essa diretiva, ele começa a interpretar o código em um modo especial. Nesse modo, erros são gerados quando certas práticas de codificação que podem acabar sendo possíveis bugs são detectadas (que é o raciocínio por trás do modo estrito).
Considere este exemplo:
var a = 365;
var b = 030;
Em sua obsessão em alinhar os literais numéricos, o desenvolvedor inicializou inadvertidamente a variável b com um literal octal. O modo não estrito interpretará isso como um literal numérico com valor 24 (na base 10). No entanto, o modo estrito gerará um erro.
Para uma lista não exaustiva de especialidades no modo restrito, veja esta resposta.
Onde devo usar 'use strict' ;?
Em meu novo aplicativo JavaScript: Com certeza! O modo estrito pode ser usado como um denunciante quando você está fazendo algo estúpido com seu código.
No meu código JavaScript existente: Provavelmente não! Se o seu código JavaScript existente tiver instruções proibidas no modo estrito, o aplicativo simplesmente será interrompido. Se você deseja o modo estrito, deve estar preparado para depurar e corrigir o código existente. É por isso que usar 'use strict'; não torna seu código melhor de repente.
Como faço para usar o modo estrito?
Insira um 'use estrito'; declaração sobre o seu script:
// Arquivo: myscript.js
'use estrito';
var a = 2;
....
Observe que tudo no arquivo myscript.js será interpretado no modo estrito.
Ou insira um 'use estrito'; declaração no topo de seu corpo de função:
function doSomething () {
'use estrito';
...
}
Tudo no escopo léxico da função doSomething será interpretado no modo estrito. A palavra escopo léxico é importante aqui. Por exemplo, se seu código estrito chamar uma função de uma biblioteca que não seja estrita, apenas seu código será executado no modo estrito, e não a função chamada. Veja esta resposta para uma explicação melhor.
O que é proibido no modo estrito?
Encontrei um bom artigo que descreve várias coisas que são proibidas no modo estrito (observe que esta não é uma lista exclusiva):
Escopo
Historicamente, o JavaScript tem se confundido sobre como as funções
têm escopo. Às vezes, eles parecem ter um escopo estático, mas alguns
os recursos fazem com que eles se comportem como se tivessem um escopo dinâmico. Isto é
confuso, tornando os programas difíceis de ler e compreender.
O mal-entendido causa bugs. Também é um problema de desempenho.
O escopo estático permitiria que a vinculação variável aconteça na compilação
tempo, mas o requisito de escopo dinâmico significa que a ligação deve ser
adiado para o tempo de execução, que vem com um desempenho significativo
pena.
O modo estrito requer que todas as vinculações de variáveis ​​sejam feitas estaticamente.
Isso significa que os recursos que antes exigiam vinculação dinâmica
deve ser eliminado ou modificado. Especificamente, a instrução with é
eliminado, e a capacidade da função eval de adulterar o
ambiente de seu chamador é severamente restrito.
Um dos benefícios do código estrito é que ferramentas como o YUI Compressor
pode fazer um trabalho melhor ao processá-lo.
Variáveis ​​globais implícitas
JavaScript tem variáveis ​​globais implícitas. E se
você não declara explicitamente uma variável, uma variável global é
declarado implicitamente para você. Isso torna a programação mais fácil para
iniciantes porque podem negligenciar algumas de suas tarefas domésticas básicas
tarefas. Mas torna a gestão de programas maiores muito mais
difícil e degrada significativamente a confiabilidade. Então em estrito
modo, as variáveis ​​globais implícitas não são mais criadas. Você deve
declare explicitamente todas as suas variáveis.
Vazamento Global
Existem várias situações que podem causar este
para ser vinculado ao objeto global. Por exemplo, se você esquecer de
forneça o novo prefixo ao chamar um construtorfunção, o
do construtor, isso será ligado inesperadamente ao objeto global, então
em vez de inicializar um novo objeto, será silenciosamente
adulteração de variáveis ​​globais. Nessas situações, o modo estrito irá
em vez disso, vincule isso a undefined, o que fará com que o construtor
lançar uma exceção em vez disso, permitindo que o erro seja detectado muito
mais cedo.
Falha ruidosa
JavaScript sempre teve propriedades somente leitura, mas você
não poderia criá-los você mesmo até Object.createProperty do ES5
função expôs essa capacidade. Se você tentou atribuir um valor
para uma propriedade somente leitura, ele falhará silenciosamente. A tarefa seria
não altere o valor da propriedade, mas seu programa continuará como
embora tivesse. Este é um risco de integridade que pode fazer com que os programas
entrar em um estado inconsistente. No modo estrito, a tentativa de alterar um
propriedade somente leitura lançará uma exceção.
Octal
A representação octal (ou base 8) dos números era extremamente
útil ao fazer programação em nível de máquina em máquinas cuja palavra
os tamanhos eram múltiplos de 3. Você precisava de octal ao trabalhar com o CDC
6600 mainframe, que tinha um tamanho de palavra de 60 bits. Se você pudesse ler
octal, você pode ver uma palavra com 20 dígitos. Dois dígitos representados
o código op, e um dígito identificou um dos 8 registros. Durante o
transição lenta de códigos de máquina para linguagens de alto nível, foi
considerado útil para fornecer formas octais em linguagens de programação.
Em C, uma representação extremamente infeliz de octalidade foi
selecionado: zero à esquerda. Então, em C, 0100 significa 64, não 100, e 08 é um
erro, não 8. Ainda mais infelizmente, esse anacronismo foi
copiado em quase todas as linguagens modernas, incluindo JavaScript, onde
é usado apenas para criar erros. Não tem outro propósito. Então em
modo estrito, as formas octais não são mais permitidas.
Et cetera
O pseudo array de argumentos torna-se um pouco mais
como matriz no ES5. No modo estrito, ele perde seu receptor e chamador
propriedades. Isso torna possível passar seus argumentos para não confiáveis
código sem abrir mão de muito contexto confidencial. Também o
A propriedade de argumentos das funções é eliminada.
No modo estrito, chaves duplicadas em um literal de função produzirão um
erro de sintaxe. Uma função não pode ter dois parâmetros com o mesmo nome.
Uma função não pode ter uma variável com o mesmo nome de um de seus
parâmetros. Uma função não pode excluir suas próprias variáveis. Uma tentativa de
excluir uma propriedade não configurável agora lança uma exceção. Primitivo
os valores não são implicitamente agrupados.
Palavras reservadas para futuras versões de JavaScript
ECMAScript 5 adiciona uma lista de palavras reservadas. Se você usá-los como variáveis ​​ou argumentos, o modo estrito gerará um erro. As palavras reservadas são:
implementa, interface, let, package, private, protected, public, static, and yield
Leitura Adicional
Modo estrito - JavaScript | MDN
Suporte do navegador para modo estrito
Fazendo a transição para o modo estrito
|
Recomendo fortemente a todos os desenvolvedores que comecem a usar o modo estrito agora. Existem navegadores suficientes para suportá-lo que o modo estrito ajudará legitimamente a nos salvar de erros que nem sabíamos que existiam em seu código.
Aparentemente, no estágio inicial, haverá erros que nunca encontramos antes. Para obter todos os benefícios, precisamos fazer os testes adequados após alternar para o modo estrito para garantir que capturamos tudo. Definitivamente, não apenas lançamos o uso estrito em nosso código e assumimos que não há erros. Portanto, é hora de começar a usar esse recurso de linguagem incrivelmente útil para escrever um código melhor.
Por exemplo,
var person = {
nome: 'xyz',
posição: 'abc',
fullname: function () {"use strict"; return this.name; }
};
JSLint é um depurador escrito por Douglas Crockford. Basta colar seu script e ele fará uma varredura rápida em busca de quaisquer problemas e erros perceptíveis em seu código.
|
Eu gostaria de oferecer uma resposta um pouco mais fundamentada, complementando as outras respostas. Eu esperava editar a resposta mais popular, mas falhei. Tentei torná-lo o mais abrangente e completo que pude.
Você pode consultar a documentação do MDN para obter mais informações.
"use strict" uma diretiva introduzida no ECMAScript 5.
As diretivas são semelhantes às declarações, mas diferentes.
use strict não contém palavras-chave: a diretiva é uma instrução de expressão simples, que consiste em um literal de string especial (entre aspas simples ou duplas). Os mecanismos JavaScript, que não implementam ECMAScript 5, apenas veem uma instrução de expressão sem efeitos colaterais. Espera-se que versões futuras dos padrões ECMAScript introduzam o uso como uma palavra-chave real; as citações se tornariam obsoletas.
use strict pode ser usado apenas no início de um script ou de uma função, ou seja, deve preceder todas as outras instruções (reais). Não precisa ser a primeira instrução em um script de função: pode ser precedida por outras expressões de instrução que consistem em literais de string (e JavaScriptimplementações podem tratá-los como diretivas específicas de implementação). As declarações de literais de string, que seguem uma primeira declaração real (em um script ou função) são declarações de expressão simples. Os intérpretes não devem interpretá-las como diretivas e não têm efeito.
A diretiva use strict indica que o código a seguir (em um script ou função) é um código estrito.
O código no nível mais alto de um script (código que não está em uma função) é considerado código estrito quando o script contém uma diretiva de uso estrito.
O conteúdo de uma função é considerado código estrito quando a própria função é definida em um código estrito ou quando a função contém uma diretiva de uso estrito.
O código que é passado para um método eval () é considerado código estrito quando eval () foi chamado de um código estrito ou contém a própria diretiva use strict.
O modo estrito do ECMAScript 5 é um subconjunto restrito da linguagem JavaScript, que elimina deficiências relevantes da linguagem e apresenta verificação de erros mais rigorosa e maior segurança. O seguinte lista as diferenças entre o modo estrito e o modo normal (dos quais os três primeiros são particularmente importantes):
Você não pode usar a instrução with no modo estrito.
No modo estrito, todas as variáveis ​​devem ser declaradas: se você atribuir um valor a um identificador que não foi declarado como variável, função, parâmetro de função, parâmetro de cláusula catch ou propriedade do objeto global, você receberá um ReferenceError. No modo normal, o identificador é declarado implicitamente como uma variável global (como uma propriedade do objeto global)
No modo estrito, a palavra-chave this possui o valor undefined em funções que foram chamadas como funções (não como métodos). (No modo normal, isso sempre aponta para o objeto global). Essa diferença pode ser usada para testar se uma implementação suporta o modo estrito:
var hasStrictMode = (function () {"use strict"; retornar este === undefined} ());
Além disso, quando uma função é chamada com call () ou aplicada no modo estrito, esse é exatamente o valor do primeiro argumento da chamada call () ou apply (). (No modo normal, nulos e indefinidos são substituídos pelo Objeto global e os valores, que não são objetos, são convertidos em objetos.)
No modo estrito, você obterá um TypeError, ao tentar atribuir propriedades somente leitura ou definir novas propriedades para um objeto não extensível. (No modo normal, ambos simplesmente falham sem mensagem de erro.)
No modo estrito, ao passar código para eval (), você não pode declarar ou definir variáveis ​​ou funções no escopo do chamador (como você pode fazer no modo normal). Em vez disso, um novo escopo é criado para eval () e as variáveis ​​e funções estão dentro desse escopo. Esse escopo é destruído depois que eval () termina a execução.
No modo estrito, o objeto de argumentos de uma função contém uma cópia estática dos valores, que são passados ​​para essa função. No modo normal, o objeto-argumentos tem um comportamento um tanto "mágico": os elementos do array e os parâmetros da função nomeada fazem referência ao mesmo valor.
No modo estrito, você obterá um SyntaxError quando o operador delete for seguido por um identificador não qualificado (uma variável, função ou parâmetro de função). No modo normal, a expressão de exclusão não faria nada e é avaliada como falsa.
No modo estrito, você obterá um TypeError ao tentar excluir uma propriedade não configurável. (No modo normal, a tentativa simplesmente falha e a expressão de exclusão é avaliada como falsa).
No modo estrito, é considerado um erro sintático quando você tenta definir várias propriedades com o mesmo nome para um literal de objeto. (No modo normal, não há erro.)
No modo estrito, é considerado um erro sintático quando uma declaração de função possui vários parâmetros com o mesmo nome. (No modo normal, não há erro.)
No modo estrito, literais octais não são permitidos (são literais que começam com 0x. (No modo normal, algumas implementações permitem literais octais).
No modo estrito, os identificadores eval e argumentos são tratados como palavras-chave. Você não pode alterar seu valor, não pode atribuir um valor a eles e não pode usá-los como nomes para variáveis, funções, parâmetros de função ou identificadores de um bloco catch.
No modo estrito, existem mais restrições às possibilidades de examinar a pilha de chamadas. argumentos.caller e argumentos.callee causam um TypeError em uma função no modo estrito. Além disso, algumas propriedades do chamador e dos argumentos das funções no modo estrito causam um TypeError quando você tenta lê-las.
|
Meus dois centavos:
Um dos objetivos do modo estrito é permitir a depuração de problemas mais rápida. Isso ajuda os desenvolvedores, lançando uma exceção quando certas coisas erradas ocorrem que podem causar um comportamento silencioso e estranho de sua página da web. No momento em que usamos use strict, o código irá gerar erros que ajudam o desenvolvedor a corrigi-lo antecipadamente.
Algumas coisas importantes que aprendi depois de usar use strict:
Impede a declaração de variável global:
var tree1Data= {nome: 'Banana Tree', idade: 100, leafCount: 100000};
function Tree (typeOfTree) {
var age;
var leafCount;
idade = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = nova árvore (tree1Data);
console.log (janela);
Agora, este código cria nameoftree no escopo global que pode ser acessado usando window.nameoftree. Quando implementamos o uso estrito, o código gera um erro.
ReferenceError não capturado: nome da árvore não está definido
Amostra
Elimina com declaração:
com declarações não pode ser minimizado usando ferramentas como uglify-js. Eles também foram descontinuados e removidos de versões futuras do JavaScript.
Amostra
Previne duplicatas:
Quando temos propriedade duplicada, ele lança uma exceção
SyntaxError não capturado: propriedade de dados duplicada no objeto literal não
permitido no modo estrito
"use estrito";
var tree1Data = {
nome: 'Banana Tree',
idade: 100,
leafCount: 100000,
nome: 'Banana Tree'
};
Existem mais alguns, mas preciso obter mais conhecimento sobre isso.
|
Se você usa um navegador lançado no ano passado, provavelmente ele suporta o modo JavaScript Strict. Apenas navegadores mais antigos antes do ECMAScript 5 se tornar o padrão atual não o suportam.
As aspas ao redor do comando garantem que o código ainda funcionará em navegadores mais antigos também (embora as coisas que geram um erro de sintaxe no modo estrito geralmente farão com que o script funcione mal de alguma forma difícil de detectar nesses navegadores mais antigos).
|
Ao adicionar "use strict"; os seguintes casos lançarão um SyntaxError antes que o script seja executado:
Pavimentando o caminho para futuras versões do ECMAScript, usando uma das palavras-chave reservadas recentemente (em previsão para ECMAScript 6): implements, interface, let, package, private, protected, public, static, and yield.
Declaração de função em blocos
if (a : 3: 15)
em : 6: 5
Aqui, o compilador lança o erro de referência. No modo estrito, o compilador não nos permite usar a variável sem declará-la. Assim, os vazamentos de memória podem ser evitados. Além disso, podemos escrever um código mais otimizado.
|
O modo estrito elimina erros que seriam ignorados no modo não estrito, tornando o javascript “mais seguro”.
É considerado uma das melhores práticas?
Sim, é considerado parte das práticas recomendadas ao trabalhar com javascript para incluir o modo estrito. Isso é feito adicionando a linha de código abaixo em seu arquivo JS.
'use estrito';
em seu código.
O que isso significa para os agentes do usuário?
A indicação de que o código deve ser interpretado no modo estrito especifica aos agentes do usuário, como navegadores, que eles devem tratar o código literalmente como escrito e gerar um erro se o código não fizer sentido.
Por exemplo: considere que em seu arquivo .js você tem o seguinte código:
Cenário 1: [SEM MODO RIGOROSO]
var city = "Chicago"
console.log (city) // Imprime o nome da cidade, ou seja, Chicago
Cenário 2: [SEM MODO RIGOROSO]
cidade = "Chicago"
console.log (city) // Imprime o nome da cidade, ou seja, Chicago
Então, por que o nome da variável está sendo impresso em ambos os casos?
Sem o modo estrito ativado, os agentes do usuário geralmente passam por uma série de modificações no código problemático na tentativa de fazer com que faça sentido. Superficialmente, isso pode parecer uma coisa boa e, de fato, trabalhar fora do modo estrito torna possível para as pessoas começarem a usar o código JavaScript sem ter todos os detalhes bem definidos. No entanto, como desenvolvedor, não quero deixar um bug no meu código, porque sei que ele pode voltar e me morder mais tarde, e também quero escrever um bom código. E é aí que o modo estrito ajuda.
Cenário 3: [MODO RIGOROSO]
'use estrito';
cidade = "Chicago"
console.log (city) // Erro de referência: atribuição é cidade de variável não declarada.
Dica adicional: para manter a qualidade do código usando o modo estrito, você não precisa escrever isso repetidamente, especialmente se tiver vários arquivos .js. Você pode aplicar essa regra globalmente nas regras eslint da seguinte maneira:
Nome do arquivo: .eslintrc.js
module.exports = {
env: {
es6: verdadeiro
},
regras : {
estrito: ['erro', 'global'],
},
};
Ok, então o que é evitado no modo estrito?
Usar uma variável sem declará-la gerará um erro no modo estrito. Isso evita a criação acidental de variáveis ​​globais em todo o aplicativo. O exemplo com impressão de Chicago cobre isso em particular.
Excluir uma variável, função ou argumento é proibido no modo estrito.
"use estrito";
função x (p1, p2) {};
delete x; // Isso causará um erro
A duplicação de um nome de parâmetro não é permitida no modo estrito.
"use estrito";
função x (p1, p1) {}; // Isso causará um erro
Palavras reservadas na linguagem Javascript não são permitidas no modo estrito. As palavras são implements interface, let, packages, private, protected, public. estático e rendimento
Para uma lista mais abrangente, verifique a documentação MDN aqui: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode
|
Questão altamente ativa. Ganhe 10 reputação para responder a esta pergunta. O requisito de reputação ajuda a proteger essa pergunta contra spam e atividades sem resposta.
Não é a resposta que você está procurando? Navegue por outras questões com a sintaxe javascript marcada com jslint use-strict ou faça sua própria pergunta.